// cf-587c
// 题意：
// 给定一棵n(<=10^5)节点的数，现在有m(<=10^5)个人，每个人有不同的id，
// 在一个节点上。一个节点可能没人，也可能有多个人，现在你有q(<=10^5)
// 个询问，每个询问是(u, v, a)，你要输出u到v路径上节点里所有人，按
// 编号从小到大排序的前a(<=10)个人的id，不足就全输出。
//
// 题解：
// 类似处理 lca 的倍增一样，每个节点预处理出来它到2^i祖先的人的标号，
// 因为a<=10，所以只需要维护不超过10个就行。用vector不会mle。
// 其实可以写 capped back inserter 来达到空间紧凑。
//
// ml:run = $bin < input
// ml:ccf += -g
// ml:opt = 0
#include <iostream>
#include <algorithm>
#include <iterator>
#include <vector>
#include <set>

int const maxn = 100007;
int const maxa = 10;
int n, m, q;
std::vector<std::vector<int>> g;

using v_type = std::vector<int>;
std::vector<v_type> pid;

v_type operator+(v_type const& a, v_type const& b)
{
    v_type result;
    result.reserve(maxa);
    std::set_union(begin(a), end(a), begin(b), end(b), std::back_inserter(result));
    result.resize(std::min(maxa, (int)result.size()));
    return result;
}

std::vector<std::vector<v_type>> people;

namespace lca
{
    int tin[maxn], tout[maxn], tick = 0, l;
    std::vector<std::vector<int>> up;

    void dfs(int u, int father = 1)
    {
        tin[u] = ++tick;
        up[u][0] = father;
        people[u][0] = pid[father] + pid[u];
        for (int i = 1; i <= l; i++) {
            up[u][i] = up[up[u][i - 1]][i - 1];
            people[u][i] = people[u][i - 1] + people[up[u][i - 1]][i - 1];
        }
        for (auto v : g[u]) {
            if (v == father) continue;
            dfs(v, u);
        }
        tout[u] = ++tick;
    }

    bool upper(int u, int v)
    {
        return tin[u] <= tin[v] && tout[u] >= tout[v];
    }

    v_type lca(int u, int v)
    {
        v_type ret;
        if (u == v) return pid[u];
        if (upper(u, v)) { std::swap(u, v); }
        for (int i = l; i >= 0; i--)
            if (!upper(up[u][i], v)) {
                ret = ret + people[u][i];
                u = up[u][i];
            }
        ret = ret + people[u][0];
        u = up[u][0];
        if (u == v) return ret;
        std::swap(u, v);
        for (int i = l; i >= 0; i--)
            if (!upper(up[u][i], v)) {
                ret = ret + people[u][i];
                u = up[u][i];
            }
        return ret + people[u][0];
    }

    void query(int u, int v, int a)
    {
        auto tmp = lca(u, v);
        tmp.resize(std::min(a, (int)tmp.size()));
        std::cout << tmp.size();
        for (auto i : tmp)
            std::cout << " " << i;
        std::cout << "\n";
    }

    void init()
    {
        l = 1;
        while ((1 << l) <= n) l++;
        up.resize(n + 1);
        up.assign(n + 1, std::vector<int>(l + 1));
        people.resize(n + 1);
        people.assign(n + 1, std::vector<v_type>(l + 1));
        dfs(1);
    }
}

void add_edge(int x, int y)
{
    g[x].push_back(y);
    g[y].push_back(x);
}

v_type dist[maxn];

void dfs(int u, int father = 0)
{
    dist[u] = dist[father] + pid[u];
    for (auto v : g[u]) {
        if (v == father) continue;
        dfs(v, u);
    }
}

int main()
{
    std::ios_base::sync_with_stdio(false);
    std::cin >> n >> m >> q;
    g.resize(n + 1);
    pid.resize(n + 1);
    for (int i = 1, x, y; i < n; i++) {
        std::cin >> x >> y;
        add_edge(x, y);
    }
    for (int i = 1, x; i <= m; i++) {
        std::cin >> x;
        auto it = std::upper_bound(begin(pid[x]), end(pid[x]), i);
        pid[x].insert(it, i);
    }
    lca::init();
    for (int i = 0, u, v, a; i < q; i++) {
        std::cin >> u >> v >> a;
        lca::query(u, v, a);
    }
}

